import ast
import logging
from 程序核心代码.mvvm重构.基础定义.基础图形项.节点图形项.带组件带布局的节点图形项 import 带组件带布局的节点图形项
from 程序核心代码.mvvm重构.基础定义.基础模型.ast节点模型基类 import ast节点基础模型
from 程序核心代码.mvvm重构.基础定义.节点管理器.自动节点注册表 import 注册节点模型, 节点模型匹配器, 注册节点图形项

logging.basicConfig(level=logging.WARNING, format='%(asctime)s - %(levelname)s - %(message)s')
日志记录器 = logging.getLogger(__name__)

@注册节点模型(ast.ListComp)
class 列表推导式节点模型(ast节点基础模型):
    """
    列表推导式节点模型，用于表示Python中的列表推导式
    例如：[x for x in range(10) if x % 2 == 0]
    """
    def __init__(self, ast节点, 所属节点模型管理器, 上级节点=None, 节点位置=None):
        super().__init__(ast节点, 所属节点模型管理器, "列表推导式", 节点位置=节点位置, 上级节点=上级节点)

        # 设置日志级别
        if self.调试模式:
            日志记录器.setLevel(logging.DEBUG)
            日志记录器.debug(f"{self.__class__.__name__}调试模式已开启")
        else:
            日志记录器.setLevel(logging.ERROR)

        # 创建列表值输出接口
        self.添加接口到节点("数据流", "输出", 接口名称="列表值", 必须连接=True)

        # 处理元素表达式
        元素表达式节点 = 节点模型匹配器(self._ast节点.elt, self.所属节点模型管理器)
        if 元素表达式节点:
            起始接口 = 元素表达式节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
            结束接口 = self.添加接口到节点("数据流", "输入", 接口名称="元素表达式", 必须连接=True)
            起始接口.接口创建连接线模型(结束接口, self)

        # 处理生成器表达式
        for 索引, 生成器 in enumerate(self._ast节点.generators):
            # 处理迭代目标
            目标节点 = 节点模型匹配器(生成器.target, self.所属节点模型管理器)
            if 目标节点:
                起始接口 = 目标节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"目标_{索引}", 必须连接=True)
                起始接口.接口创建连接线模型(结束接口, self)

            # 处理迭代器
            迭代器节点 = 节点模型匹配器(生成器.iter, self.所属节点模型管理器)
            if 迭代器节点:
                起始接口 = 迭代器节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"迭代器_{索引}", 必须连接=True)
                起始接口.接口创建连接线模型(结束接口, self)

            # 处理条件判断
            for 条件索引, 条件 in enumerate(生成器.ifs):
                条件节点 = 节点模型匹配器(条件, self.所属节点模型管理器)
                if 条件节点:
                    起始接口 = 条件节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                    结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"条件_{索引}_{条件索引}", 必须连接=True)
                    起始接口.接口创建连接线模型(结束接口, self)

@注册节点图形项(ast.ListComp)
class 列表推导式图形节点(带组件带布局的节点图形项):
    """
    列表推导式的图形表示
    """
    def __init__(self, 节点模型, 父容器节点图形项管理器, 父项=None):
        super().__init__(节点模型, 父容器节点图形项管理器, 父项)

@注册节点模型(ast.DictComp)
class 字典推导式节点模型(ast节点基础模型):
    """
    字典推导式节点模型，用于表示Python中的字典推导式
    例如：{k: v for k, v in zip(keys, values) if k in valid_keys}
    """
    def __init__(self, ast节点, 所属节点模型管理器, 上级节点=None, 节点位置=None):
        super().__init__(ast节点, 所属节点模型管理器, "字典推导式", 节点位置=节点位置, 上级节点=上级节点)

        # 设置日志级别
        if self.调试模式:
            日志记录器.setLevel(logging.DEBUG)
            日志记录器.debug(f"{self.__class__.__name__}调试模式已开启")
        else:
            日志记录器.setLevel(logging.ERROR)

        # 创建字典值输出接口
        self.添加接口到节点("数据流", "输出", 接口名称="字典值", 必须连接=True)

        # 处理键表达式
        键表达式节点 = 节点模型匹配器(self._ast节点.key, self.所属节点模型管理器)
        if 键表达式节点:
            起始接口 = 键表达式节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
            结束接口 = self.添加接口到节点("数据流", "输入", 接口名称="键表达式", 必须连接=True)
            起始接口.接口创建连接线模型(结束接口, self)

        # 处理值表达式
        值表达式节点 = 节点模型匹配器(self._ast节点.value, self.所属节点模型管理器)
        if 值表达式节点:
            起始接口 = 值表达式节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
            结束接口 = self.添加接口到节点("数据流", "输入", 接口名称="值表达式", 必须连接=True)
            起始接口.接口创建连接线模型(结束接口, self)

        # 处理生成器表达式
        for 索引, 生成器 in enumerate(self._ast节点.generators):
            # 处理迭代目标
            目标节点 = 节点模型匹配器(生成器.target, self.所属节点模型管理器)
            if 目标节点:
                起始接口 = 目标节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"目标_{索引}", 必须连接=True)
                起始接口.接口创建连接线模型(结束接口, self)

            # 处理迭代器
            迭代器节点 = 节点模型匹配器(生成器.iter, self.所属节点模型管理器)
            if 迭代器节点:
                起始接口 = 迭代器节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"迭代器_{索引}", 必须连接=True)
                起始接口.接口创建连接线模型(结束接口, self)

            # 处理条件判断
            for 条件索引, 条件 in enumerate(生成器.ifs):
                条件节点 = 节点模型匹配器(条件, self.所属节点模型管理器)
                if 条件节点:
                    起始接口 = 条件节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                    结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"条件_{索引}_{条件索引}", 必须连接=True)
                    起始接口.接口创建连接线模型(结束接口, self)

@注册节点图形项(ast.DictComp)
class 字典推导式图形节点(带组件带布局的节点图形项):
    """
    字典推导式的图形表示
    """
    def __init__(self, 节点模型, 父容器节点图形项管理器, 父项=None):
        super().__init__(节点模型, 父容器节点图形项管理器, 父项)

@注册节点模型(ast.SetComp)
class 集合推导式节点模型(ast节点基础模型):
    """
    集合推导式节点模型，用于表示Python中的集合推导式
    例如：{x for x in range(10) if x % 2 == 0}
    """
    def __init__(self, ast节点, 所属节点模型管理器, 上级节点=None, 节点位置=None):
        super().__init__(ast节点, 所属节点模型管理器, "集合推导式", 节点位置=节点位置, 上级节点=上级节点)

        # 设置日志级别
        if self.调试模式:
            日志记录器.setLevel(logging.DEBUG)
            日志记录器.debug(f"{self.__class__.__name__}调试模式已开启")
        else:
            日志记录器.setLevel(logging.ERROR)

        # 创建集合值输出接口
        self.添加接口到节点("数据流", "输出", 接口名称="集合值", 必须连接=True)

        # 处理元素表达式
        元素表达式节点 = 节点模型匹配器(self._ast节点.elt, self.所属节点模型管理器)
        if 元素表达式节点:
            起始接口 = 元素表达式节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
            结束接口 = self.添加接口到节点("数据流", "输入", 接口名称="元素表达式", 必须连接=True)
            起始接口.接口创建连接线模型(结束接口, self)

        # 处理生成器表达式
        for 索引, 生成器 in enumerate(self._ast节点.generators):
            # 处理迭代目标
            目标节点 = 节点模型匹配器(生成器.target, self.所属节点模型管理器)
            if 目标节点:
                起始接口 = 目标节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"目标_{索引}", 必须连接=True)
                起始接口.接口创建连接线模型(结束接口, self)

            # 处理迭代器
            迭代器节点 = 节点模型匹配器(生成器.iter, self.所属节点模型管理器)
            if 迭代器节点:
                起始接口 = 迭代器节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"迭代器_{索引}", 必须连接=True)
                起始接口.接口创建连接线模型(结束接口, self)

            # 处理条件判断
            for 条件索引, 条件 in enumerate(生成器.ifs):
                条件节点 = 节点模型匹配器(条件, self.所属节点模型管理器)
                if 条件节点:
                    起始接口 = 条件节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                    结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"条件_{索引}_{条件索引}", 必须连接=True)
                    起始接口.接口创建连接线模型(结束接口, self)

@注册节点图形项(ast.SetComp)
class 集合推导式图形节点(带组件带布局的节点图形项):
    """
    集合推导式的图形表示
    """
    def __init__(self, 节点模型, 父容器节点图形项管理器, 父项=None):
        super().__init__(节点模型, 父容器节点图形项管理器, 父项)

@注册节点模型(ast.GeneratorExp)
class 生成器表达式节点模型(ast节点基础模型):
    """
    生成器表达式节点模型，用于表示Python中的生成器表达式
    例如：(x for x in range(10) if x % 2 == 0)
    """
    def __init__(self, ast节点, 所属节点模型管理器, 上级节点=None, 节点位置=None):
        super().__init__(ast节点, 所属节点模型管理器, "生成器表达式", 节点位置=节点位置, 上级节点=上级节点)

        # 设置日志级别
        if self.调试模式:
            日志记录器.setLevel(logging.DEBUG)
            日志记录器.debug(f"{self.__class__.__name__}调试模式已开启")
        else:
            日志记录器.setLevel(logging.ERROR)

        # 创建生成器值输出接口
        self.添加接口到节点("数据流", "输出", 接口名称="生成器值", 必须连接=True)

        # 处理元素表达式
        元素表达式节点 = 节点模型匹配器(self._ast节点.elt, self.所属节点模型管理器)
        if 元素表达式节点:
            起始接口 = 元素表达式节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
            结束接口 = self.添加接口到节点("数据流", "输入", 接口名称="元素表达式", 必须连接=True)
            起始接口.接口创建连接线模型(结束接口, self)

        # 处理生成器表达式
        for 索引, 生成器 in enumerate(self._ast节点.generators):
            # 处理迭代目标
            目标节点 = 节点模型匹配器(生成器.target, self.所属节点模型管理器)
            if 目标节点:
                起始接口 = 目标节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"目标_{索引}", 必须连接=True)
                起始接口.接口创建连接线模型(结束接口, self)

            # 处理迭代器
            迭代器节点 = 节点模型匹配器(生成器.iter, self.所属节点模型管理器)
            if 迭代器节点:
                起始接口 = 迭代器节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"迭代器_{索引}", 必须连接=True)
                起始接口.接口创建连接线模型(结束接口, self)

            # 处理条件判断
            for 条件索引, 条件 in enumerate(生成器.ifs):
                条件节点 = 节点模型匹配器(条件, self.所属节点模型管理器)
                if 条件节点:
                    起始接口 = 条件节点.添加接口到节点("数据流", "输出", 接口名称="值", 必须连接=True)
                    结束接口 = self.添加接口到节点("数据流", "输入", 接口名称=f"条件_{索引}_{条件索引}", 必须连接=True)
                    起始接口.接口创建连接线模型(结束接口, self)

# @注册节点图形项(ast.GeneratorExp)
# class 生成器表达式图形节点(带组件带布局的节点图形项):
#     """
#     生成器表达式的图形表示
#     """
#     def __init__(self, 节点模型, 父容器节点图形项管理器, 父项=None):
#         super().__init__(节点模型, 父容器节点图形项管理器, 父项)